Higher-Level Synchronization and Communication 3.1 SHARED MEMORY METHODS 3.2 DISTRIBUTED SYNCHRONIZATION AND COMMUNICATION 3.3 OTHER CLASSIC SYNCHRONIZATION PROBLEMS

The main objections to semaphores and events—the synchronization mechanisms introduced in the last chapter—are that they are too low level and do not support the elegant structuring of concurrent programs. For example, they do not permit a segment of code to be designated explicitly as a critical section (CS). Rather, the effect of a CS must be enforced by correctly using the semaphore operations, i.e., by enclosing the desired segment between a pair of P and V operations and presetting the corresponding semaphore to 1, or by employing a mutex lock and mutex unlock pair correctly. Violating any of these rules will destroy the desired effect. Since P and V operations may be used anywhere in a program, the task of understanding and verifying the desired behavior of programs becomes very difficult. One common error that is usually extremely difficult to detect is the omission of a required V operation from a program or its mere bypassing when execution follows some unexpected path; this could result in a situation where processes are blocked forever—a situation commonly referred to as deadlock. Equally dangerous and common is an unintentional execution of a V operation, permitting, e.g., more than one process to enter a CS. The first part of the chapter presents several constructs that are used as alternatives to the low-level semaphore and event operations. These are based on ideas from abstract data types and objects. The aim is to concentrate and encapsulate all accesses to a shared resource, including any required synchronization. These mechanisms assume that processes share parts of main memory. However, it is not always desirable or possible that processes share some portion of memory. For example, it is sound software engineering practice to encapsulate program entities, including processes, as a way to improve understanding, analysis, and reusability. Shared memory is in conflict with this principle. For security reasons, processes often must run in isolation, each in its own logical space, with all interactions under strict control of the participating process. Another reason for alternatives to shared memory constructs is the increasing importance and use of distributed systems. In such environments, each processor may have only its own local memory; consequently, there can be no direct data sharing among processes running on different processors. For these reasons, distributed schemes for interprocess communication (IPC) and synchronization are commonly available.